#include <iostream>
#include <thread>
#include <vector>
#include <mutex> //引入互斥锁
std::mutex mtx;
void example_defer_lock() 
{
    std::unique_lock<std::mutex> mylock(mtx,std::defer_lock);//不会立即上锁,上了锁忘记解锁不会报错，但是不上锁解锁会报错
    //不上锁和解锁，相当于什么都没写，只是建立了这种锁的关系
    //去掉后面的选项，相当于 lock_guard 自动加锁解锁
    //...执行一些操作
    mylock.lock();//需要显示锁定
    std::cout << "Locked with defer_lock" << std::endl;
    mylock.unlock();// 显示解锁
}
int main() 
{
    return 0;
}
//1. lock_guard是对mutex的一种封装，如果有两个for循环那么lock_guard一杆子到底,无法中途解锁，生命周期结束才解锁
//2. unique_lock可以中途解锁
//为什么使用lock_guard？？1.忘记解锁，会自动解锁。2。异常安全
//std::mutex mymutex; //定义互斥锁
//int mycount1 = 0;
//int mycount2 = 0;
//void sum() 
//{
//    //mymutex.lock();
//    std::lock_guard<std::mutex> mylock(mymutex); // 我保护的是mutex类型的锁，它是mymutex 超出生命周期，自动解锁
//    for(size_t i = 0; i < 10000; ++i) 
//    {
//        ++mycount1;
//    }
//    for(size_t i= 0; i < 10000; ++i)
//    {
//        ++mycount2;
//    }
//    //mymutex.unlock();
//}
//int main() 
//{
//    std::vector<std::thread> mybox;
//    for(size_t i = 0; i< 10; ++i) 
//    {
//        mybox.emplace_back(sum);
//    }
//    //阻塞主线程，即等待所以线程执行完毕
//    for(auto& mythread : mybox) 
//    {
//        mythread.join();
//    }
//    //最后结果
//    std::cout << "最后结果:" << mycount1 << std::endl;
//    std::cout << "最后结果:" << mycount2 << std::endl;
//    return 0;
//}
//std::mutex mymutex;//定义一个互斥锁
////共享变量
//int counter = 0;
////线程函数，对counter进行递增操作
//void increment_counter(int times) 
//{
//    for(int i = 0; i< times; ++i) 
//    {
//        //这是一个数据竞争，因为多个线程可能同时执行这个代码
//        mymutex.lock(); //在访问临界变量之前先加锁
//        ++counter;
//        mymutex.unlock();//访问完了解锁，把锁交出
//    }
//}
//int main() 
//{
//    //每个线程对counter递增10000次
//    std::thread t1(increment_counter,10000);
//    std::thread t2(increment_counter,10000);
//    //等待两个线程完成
//    t1.join();
//    t2.join();
//    std::cout << "最终结果"<< counter << std::endl;
//    return 0;
//}
//std::thread
//void func1(int a,int b) 
//{
//    std::cout << "hello" <<" " << a <<" "<< b << std::endl;
//}
//void func(int& a, int&  b) 
//{
//    int i = 0 ;
//    while(i < 1000) 
//    {
//       std::cout << i<< " 子线程的ID:"<<std::this_thread::get_id() <<"|" << "hello "<< a << " " << b << std::endl;
//       ++i;
//    }
//}
//int main() 
//{
//    //main 所在的线程就是主线程
//
//    //创建子线程，打印一个hello
//    //可调对象，lambda表达式，仿函数
//    //std::thread t1(func1); //t1就是一个子线程
//    // std::thread t1([](){std::cout<<"hello lambda"<<std::endl;}); //t1就是一个子线程
//    int a = 10;
//    int b  = 25;
//    std::thread t1(func,std::ref(a),std::ref(b));
//    t1.join();//阻塞主线程,等我t1结束了你再结束主线程
//   //t1.detach();//从主线程中分离出去
//   // int i = 0 ;
//   // while(i <200) 
//   // {
//   //     std::cout << i << std::endl;
//   //     ++i;
//   // }
//    //  std::this_thread::sleep_for(5s);
//    std::cout<< "this is main主线程ID:" << std::this_thread::get_id()<<"|" << std::endl;
//    return 0;
//}


//std::mutex mymutex;
//void sum() 
//{
//    
//    // std::lock_guard<std::mutex> lock(mymutex);
//    
//    std::unique_lock<std::mutex> lock(mymutex,std::defer_lock);//不会立即锁定
//    lock.lock();
//    std::cout <<"Lock code defer_lock"<< std::endl;
//    lock.unlock();
//    //for(size_t i  = 0; i< 10000; ++i) 
//    //{
//    //    ++mycount;
//    //}
//    //
//    //for(size_t i = 0; i< 10000; ++i)
//    //{
//    //    ++mycount1;
//    //}
//    //到这里才解锁
//}
//int main() 
//{
//    std::thread t1(sum);
//    std::thread t2(sum);
//    t1.join();
//    t2.join();
//   // std::cout << mycount <<":" << mycount1 <<std::endl;
//    return 0;
//}
